Python SQLAlchemy Zarządzanie Sesją: Mistrzostwo w Obsłudze Transakcji dla Integralności Danych

SQLAlchemy to potężna i elastyczna biblioteka Pythona, która zapewnia kompleksowy zestaw narzędzi do interakcji z bazami danych. Sercem SQLAlchemy jest koncepcja sesji, która działa jako obszar roboczy dla wszystkich operacji wykonywanych na bazie danych. Odpowiednie zarządzanie sesją i transakcjami jest kluczowe dla utrzymania integralności danych i zapewnienia spójnego zachowania bazy danych, szczególnie w złożonych aplikacjach obsługujących współbieżne żądania.

Zrozumienie Sesji SQLAlchemy

Sesja SQLAlchemy reprezentuje jednostkę pracy, konwersację z bazą danych. Śledzi zmiany wprowadzone do obiektów, umożliwiając utrwalenie ich w bazie danych jako pojedynczej, atomowej operacji. Pomyśl o tym jako o obszarze roboczym, w którym wprowadzasz modyfikacje do danych przed oficjalnym zapisaniem ich. Bez dobrze zarządzanej sesji ryzykujesz niespójności danych i potencjalne uszkodzenia.

Tworzenie Sesji

Zanim zaczniesz wchodzić w interakcje z bazą danych, musisz utworzyć sesję. Obejmuje to najpierw ustanowienie połączenia z bazą danych za pomocą mechanizmu SQLAlchemy.

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Database connection string
db_url = 'sqlite:///:memory:'  # Replace with your database URL (e.g., PostgreSQL, MySQL)

# Create an engine
engine = create_engine(db_url, echo=False) # echo=True to see the generated SQL

# Define a base for declarative models
Base = declarative_base()

# Define a simple model
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

# Create the table in the database
Base.metadata.create_all(engine)

# Create a session class
Session = sessionmaker(bind=engine)

# Instantiate a session
session = Session()

            

              
                Copy
              
            
          

W tym przykładzie:

• Importujemy niezbędne moduły SQLAlchemy.
• Definiujemy ciąg połączenia z bazą danych (`db_url`). Ten przykład używa bazy danych SQLite w pamięci dla uproszczenia, ale należy go zastąpić ciągiem połączenia odpowiednim dla używanego systemu bazy danych (np. PostgreSQL, MySQL). Konkretny format różni się w zależności od silnika bazy danych i używanego sterownika. Skonsultuj się z dokumentacją SQLAlchemy i dokumentacją dostawcy bazy danych, aby uzyskać poprawny format ciągu połączenia.
• Tworzymy `engine` za pomocą `create_engine()`. Mechanizm jest odpowiedzialny za zarządzanie pulą połączeń i komunikację z bazą danych. Parametr `echo=True` może być pomocny podczas debugowania, ponieważ spowoduje wydrukowanie wygenerowanych instrukcji SQL w konsoli.
• Definiujemy klasę bazową (`Base`) za pomocą `declarative_base()`. Jest ona używana jako klasa bazowa dla wszystkich naszych modeli SQLAlchemy.
• Definiujemy model `User`, mapując go na tabelę bazy danych o nazwie `users`.
• Tworzymy tabelę w bazie danych za pomocą `Base.metadata.create_all(engine)`.
• Tworzymy klasę sesji za pomocą `sessionmaker(bind=engine)`. Konfiguruje to klasę sesji do korzystania z określonego mechanizmu.
• Na koniec tworzymy instancję sesji za pomocą `Session()`.

Zrozumienie Transakcji

Transakcja to sekwencja operacji na bazie danych traktowana jako pojedyncza, logiczna jednostka pracy. Transakcje przestrzegają właściwości ACID:

• Atomowość: Wszystkie operacje w transakcji albo kończą się całkowitym sukcesem, albo całkowitą porażką. Jeśli jakakolwiek część transakcji nie powiedzie się, cała transakcja jest wycofywana.
• Spójność: Transakcja musi utrzymywać bazę danych w prawidłowym stanie. Nie może naruszać żadnych ograniczeń ani reguł bazy danych.
• Izolacja: Współbieżne transakcje są od siebie izolowane. Zmiany dokonane przez jedną transakcję nie są widoczne dla innych transakcji, dopóki pierwsza transakcja nie zostanie zatwierdzona.
• Trwałość: Po zatwierdzeniu transakcji zmiany są trwałe i przetrwają nawet awarie systemu.

SQLAlchemy zapewnia mechanizmy zarządzania transakcjami, zapewniając utrzymanie tych właściwości ACID.

Podstawowa Obsługa Transakcji

Najczęstsze operacje transakcyjne to commit i rollback.

Zatwierdzanie Transakcji

Gdy wszystkie operacje w transakcji zostaną pomyślnie zakończone, zatwierdzasz transakcję. Powoduje to utrwalenie zmian w bazie danych.

            try:
    # Add a new user
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Commit the transaction
    session.commit()
    print("Transaction committed successfully!")

except Exception as e:
    # Handle exceptions
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back.")

finally:
    session.close()

            

              
                Copy
              
            
          

W tym przykładzie:

• Dodajemy nowy obiekt `User` do sesji.
• Wywołujemy `session.commit()`, aby utrwalić zmiany w bazie danych.
• Owijamy kod w blok `try...except...finally`, aby obsłużyć potencjalne wyjątki.
• Jeśli wystąpi wyjątek, wywołujemy `session.rollback()`, aby cofnąć wszelkie zmiany wprowadzone podczas transakcji.
• Zawsze wywołujemy `session.close()` w bloku `finally`, aby zwolnić sesję i zwrócić połączenie do puli połączeń. Jest to kluczowe, aby uniknąć wycieków zasobów. Niezamknięcie sesji może prowadzić do wyczerpania połączeń i niestabilności aplikacji.

Wycofywanie Transakcji

Jeśli podczas transakcji wystąpi jakikolwiek błąd lub jeśli zdecydujesz, że zmiany nie powinny być utrwalane, wycofujesz transakcję. Powoduje to przywrócenie bazy danych do stanu sprzed rozpoczęcia transakcji.

            try:
    # Add a user with an invalid email (example to force a rollback)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # The commit will fail if the email is not validated on the database level
    session.commit()
    print("Transaction committed.")

except Exception as e:
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back successfully.")

finally:
    session.close()

            

              
                Copy
              
            
          

W tym przykładzie, jeśli dodanie `invalid_user` zgłosi wyjątek (np. z powodu naruszenia ograniczenia bazy danych), wywołanie `session.rollback()` cofnie próbę wstawienia, pozostawiając bazę danych bez zmian.

Zaawansowane Zarządzanie Transakcjami

Używanie Instrukcji `with` do Określania Zakresu Transakcji

Bardziej Pythonicznym i niezawodnym sposobem zarządzania transakcjami jest użycie instrukcji `with`. Zapewnia to prawidłowe zamknięcie sesji, nawet jeśli wystąpią wyjątki.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Usage:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Operations within the 'with' block
    # If no exceptions occur, the transaction is committed automatically.
    # If an exception occurs, the transaction is rolled back automatically.
    print("User added.")

print("Transaction completed (committed or rolled back).")

            

              
                Copy
              
            
          

Funkcja `session_scope` jest menedżerem kontekstu. Po wejściu do bloku `with` tworzona jest nowa sesja. Po wyjściu z bloku `with` sesja jest albo zatwierdzana (jeśli nie wystąpiły żadne wyjątki), albo wycofywana (jeśli wystąpił wyjątek). Sesja jest zawsze zamykana w bloku `finally`.

Zagnieżdżone Transakcje (Punkty Zapisu)

SQLAlchemy obsługuje zagnieżdżone transakcje za pomocą punktów zapisu. Punkt zapisu pozwala na wycofanie do określonego punktu w większej transakcji, bez wpływu na całą transakcję.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Send changes to the database but don't commit yet

        # Create a savepoint
        savepoint = session.begin_nested()

        try:
            user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
            session.add(user2)
            session.flush()

            # Simulate an error
            raise ValueError("Simulated error during nested transaction")

        except Exception as e:
            print(f"Nested transaction error: {e}")
            savepoint.rollback()
            print("Nested transaction rolled back to savepoint.")

        # Continue with the outer transaction, user1 will still be added
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Outer transaction error: {e}")


#Commit will commit user1 and user3, but not user2 due to the nested rollback

try:
    with session_scope() as session:
        #Verify only user1 and user3 exist
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Unexpected Exception: {e}") #Should not happen

            

              
                Copy
              
            
          

W tym przykładzie:

• Rozpoczynamy zewnętrzną transakcję za pomocą `session_scope()`.
• Dodajemy `user1` do sesji i wysyłamy zmiany do bazy danych. `flush()` wysyła zmiany do serwera bazy danych, ale ich *nie* zatwierdza. Pozwala to sprawdzić, czy zmiany są prawidłowe (np. brak naruszeń ograniczeń) przed zatwierdzeniem całej transakcji.
• Tworzymy punkt zapisu za pomocą `session.begin_nested()`.
• W ramach zagnieżdżonej transakcji dodajemy `user2` i symulujemy błąd.
• Wycofujemy zagnieżdżoną transakcję do punktu zapisu za pomocą `savepoint.rollback()`. Powoduje to cofnięcie tylko zmian dokonanych w zagnieżdżonej transakcji (tj. dodania `user2`).
• Kontynuujemy zewnętrzną transakcję i dodajemy `user3`.
• Zewnętrzna transakcja jest zatwierdzana, utrwalając `user1` i `user3` w bazie danych, a `user2` jest odrzucany z powodu wycofania punktu zapisu.

Kontrolowanie Poziomów Izolacji

Poziomy izolacji określają stopień, w jakim współbieżne transakcje są od siebie izolowane. Wyższe poziomy izolacji zapewniają większą spójność danych, ale mogą zmniejszyć współbieżność i wydajność. SQLAlchemy pozwala kontrolować poziom izolacji transakcji.

Typowe poziomy izolacji obejmują:

• Read Uncommitted: Najniższy poziom izolacji. Transakcje mogą widzieć niezatwierdzone zmiany dokonane przez inne transakcje. Może to prowadzić do brudnych odczytów.
• Read Committed: Transakcje mogą widzieć tylko zatwierdzone zmiany dokonane przez inne transakcje. Zapobiega to brudnym odczytom, ale może prowadzić do niepowtarzalnych odczytów i fantomowych odczytów.
• Repeatable Read: Transakcje mogą widzieć te same dane w całej transakcji, nawet jeśli inne transakcje je modyfikują. Zapobiega to brudnym odczytom i niepowtarzalnym odczytom, ale może prowadzić do fantomowych odczytów.
• Serializable: Najwyższy poziom izolacji. Transakcje są całkowicie od siebie izolowane. Zapobiega to brudnym odczytom, niepowtarzalnym odczytom i fantomowym odczytom, ale może znacznie zmniejszyć współbieżność.

Domyślny poziom izolacji zależy od systemu bazy danych. Można ustawić poziom izolacji podczas tworzenia mechanizmu lub podczas rozpoczynania transakcji.

Przykład (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Set isolation level when creating the engine
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} #Example of timeout
                      )

# Set the isolation level when beginning a transaction (database specific)
# For postgresql, it's recommended to set it on the connection, not engine.

from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    dbapi_connection.autocommit = existing_autocommit
    cursor.close()


# Then transactions created via SQLAlchemy will use the configured isolation level.

            

              
                Copy
              
            
          

Ważne: Metoda ustawiania poziomów izolacji jest specyficzna dla bazy danych. Zapoznaj się z dokumentacją bazy danych, aby uzyskać poprawną składnię. Nieprawidłowe ustawienie poziomów izolacji może prowadzić do nieoczekiwanego zachowania lub błędów.

Obsługa Współbieżności

Gdy wielu użytkowników lub procesów uzyskuje dostęp do tych samych danych jednocześnie, kluczowe jest odpowiednie obsłużenie współbieżności, aby zapobiec uszkodzeniu danych i zapewnić ich spójność. SQLAlchemy zapewnia kilka mechanizmów obsługi współbieżności, w tym blokowanie optymistyczne i blokowanie pesymistyczne.

Blokowanie Optymistyczne

Blokowanie optymistyczne zakłada, że konflikty występują rzadko. Sprawdza, czy inne transakcje dokonały modyfikacji przed zatwierdzeniem transakcji. Jeśli zostanie wykryty konflikt, transakcja jest wycofywana.

Aby zaimplementować blokowanie optymistyczne, zazwyczaj dodajesz kolumnę wersji do tabeli. Kolumna ta jest automatycznie zwiększana przy każdej aktualizacji wiersza.

            from sqlalchemy import Column, Integer, String, Integer
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Article(Base):
    __tablename__ = 'articles'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    version = Column(Integer, nullable=False, default=1)

    def __repr__(self):
        return f""

#Inside of the try catch block

def update_article(session, article_id, new_content):
    article = session.query(Article).filter_by(id=article_id).first()

    if article is None:
        raise ValueError("Article not found")

    original_version = article.version

    # Update the content and increment the version
    article.content = new_content
    article.version += 1

    # Attempt to update, checking the version column in the WHERE clause
    rows_affected = session.query(Article).filter(
        Article.id == article_id,
        Article.version == original_version
    ).update({
        Article.content: new_content,
        Article.version: article.version
    }, synchronize_session=False)

    if rows_affected == 0:
        session.rollback()
        raise ValueError("Conflict: Article has been updated by another transaction.")
    
    session.commit()

            

              
                Copy
              
            
          

W tym przykładzie:

• Dodajemy kolumnę `version` do modelu `Article`.
• Przed aktualizacją artykułu przechowujemy bieżący numer wersji.
• W instrukcji `UPDATE` dodajemy klauzulę `WHERE`, która sprawdza, czy kolumna wersji jest nadal równa przechowywanemu numerowi wersji. `synchronize_session=False` zapobiega ponownemu załadowaniu zaktualizowanego obiektu przez SQLAlchemy; jawnie obsługujemy wersjonowanie.
• Jeśli kolumna wersji została zmieniona przez inną transakcję, instrukcja `UPDATE` nie wpłynie na żadne wiersze (rows_affected będzie równe 0) i zgłosimy wyjątek.
• Wycofujemy transakcję i powiadamiamy użytkownika o wystąpieniu konfliktu.

Blokowanie Pesymistyczne

Blokowanie pesymistyczne zakłada, że konflikty są prawdopodobne. Uzyskuje blokadę na wierszu lub tabeli przed jej modyfikacją. Zapobiega to modyfikowaniu danych przez inne transakcje do momentu zwolnienia blokady.

SQLAlchemy zapewnia kilka funkcji do uzyskiwania blokad, takich jak `with_for_update()`.

            # Example using PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Set echo to true if you would like to see the SQL generated
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    value = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

#Function to update the item (within a try/except)
def update_item_value(session, item_id, new_value):
    # Acquire a pessimistic lock on the item
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Item not found")

    # Update the item's value
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

W tym przykładzie:

• Używamy `with_for_update()`, aby uzyskać blokadę na wierszu `Item` przed jego aktualizacją. Zapobiega to modyfikowaniu wiersza przez inne transakcje do momentu zatwierdzenia lub wycofania bieżącej transakcji. Funkcja `with_for_update()` jest specyficzna dla bazy danych; zapoznaj się z dokumentacją bazy danych, aby uzyskać szczegółowe informacje. Niektóre bazy danych mogą mieć różne mechanizmy lub składnię blokowania.

Ważne: Blokowanie pesymistyczne może zmniejszyć współbieżność i wydajność, dlatego używaj go tylko w razie potrzeby.

Najlepsze Praktyki Obsługi Wyjątków

Prawidłowa obsługa wyjątków ma kluczowe znaczenie dla zapewnienia integralności danych i zapobiegania awariom aplikacji. Zawsze owijaj operacje na bazie danych w bloki `try...except` i odpowiednio obsługuj wyjątki.

Oto kilka najlepszych praktyk obsługi wyjątków:

• Wyłapuj konkretne wyjątki: Unikaj wyłapywania ogólnych wyjątków, takich jak `Exception`. Wyłapuj konkretne wyjątki, takie jak `sqlalchemy.exc.IntegrityError` lub `sqlalchemy.exc.OperationalError`, aby różnie obsługiwać różne typy błędów.
• Wycofuj transakcje: Zawsze wycofuj transakcję, jeśli wystąpi wyjątek.
• Loguj wyjątki: Loguj wyjątki, aby pomóc w diagnozowaniu i naprawianiu problemów. Dołącz jak najwięcej kontekstu do swoich logów (np. identyfikator użytkownika, dane wejściowe, znacznik czasu).
• Ponownie zgłaszaj wyjątki, gdy jest to właściwe: Jeśli nie możesz obsłużyć wyjątku, zgłoś go ponownie, aby umożliwić obsłużenie go przez obsługę wyższego poziomu.
• Oczyszczaj zasoby: Zawsze zamykaj sesję i zwalniaj inne zasoby w bloku `finally`.

            import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Function to add a product
def add_product(session, name, price):
    try:
        new_product = Product(name=name, price=price)
        session.add(new_product)
        session.commit()
        logging.info(f"Product '{name}' added successfully.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        #Handle database constraint violations (e.g., duplicate name)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        #Handle connection errors or other operational issues
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"An unexpected error occurred: {e}")
        # Handle any other unexpected errors
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

W tym przykładzie:

• Konfigurujemy logowanie do rejestrowania zdarzeń podczas procesu.
• Wyłapujemy konkretne wyjątki, takie jak `IntegrityError` (dla naruszeń ograniczeń) i `OperationalError` (dla błędów połączenia).
• Wycofujemy transakcję w blokach `except`.
• Logujemy wyjątki za pomocą modułu `logging`. Metoda `logging.exception()` automatycznie dołącza ślad stosu do komunikatu dziennika.
• Ponownie zgłaszamy wyjątek, jeśli nie możemy go obsłużyć.
• Zamykamy sesję w bloku `finally`.

Pula Połączeń z Bazą Danych

SQLAlchemy używa puli połączeń do wydajnego zarządzania połączeniami z bazą danych. Pula połączeń utrzymuje zestaw otwartych połączeń z bazą danych, umożliwiając aplikacjom ponowne wykorzystywanie istniejących połączeń zamiast tworzenia nowych dla każdego żądania. Może to znacznie poprawić wydajność, szczególnie w aplikacjach obsługujących dużą liczbę współbieżnych żądań.

Funkcja `create_engine()` SQLAlchemy automatycznie tworzy pulę połączeń. Można skonfigurować pulę połączeń, przekazując argumenty do `create_engine()`.

Typowe parametry puli połączeń obejmują:

• pool_size: Maksymalna liczba połączeń w puli.
• max_overflow: Liczba połączeń, które można utworzyć poza pulą pool_size.
• pool_recycle: Liczba sekund, po upływie których połączenie jest poddawane recyklingowi.
• pool_timeout: Liczba sekund oczekiwania na udostępnienie połączenia.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, #Maximum pool size
                       max_overflow=10, #Maximum overflow
                       pool_recycle=3600, #Recycle connections after 1 hour
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

Ważne: Wybierz odpowiednie ustawienia puli połączeń w oparciu o potrzeby aplikacji i możliwości serwera bazy danych. Źle skonfigurowana pula połączeń może prowadzić do problemów z wydajnością lub wyczerpania połączeń.

Transakcje Asynchroniczne (Async SQLAlchemy)

W przypadku nowoczesnych aplikacji wymagających wysokiej współbieżności, szczególnie tych zbudowanych z asynchronicznych frameworków, takich jak FastAPI lub AsyncIO, SQLAlchemy oferuje asynchroniczną wersję o nazwie Async SQLAlchemy.

Async SQLAlchemy zapewnia asynchroniczne wersje podstawowych komponentów SQLAlchemy, umożliwiając wykonywanie operacji na bazie danych bez blokowania pętli zdarzeń. Może to znacznie poprawić wydajność i skalowalność aplikacji.

Oto podstawowy przykład użycia Async SQLAlchemy:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio

# Database setup (replace with your actual database URL)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)


async def add_user(name, email):
    async with AsyncSession(engine) as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()

async def main():
    await create_db_and_tables()
    await add_user("Async User", "async.user@example.com")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

Kluczowe różnice w porównaniu z synchronicznym SQLAlchemy:

• `create_async_engine` jest używany zamiast `create_engine`.
• `AsyncSession` jest używany zamiast `Session`.
• Wszystkie operacje na bazie danych są asynchroniczne i muszą być oczekiwane za pomocą `await`.
• Należy używać asynchronicznych sterowników baz danych (np. `asyncpg` dla PostgreSQL).

Ważne: Async SQLAlchemy wymaga sterownika bazy danych, który obsługuje operacje asynchroniczne. Upewnij się, że masz zainstalowany i skonfigurowany poprawny sterownik.

Wnioski

Opanowanie zarządzania sesjami i transakcjami SQLAlchemy jest niezbędne do tworzenia niezawodnych i solidnych aplikacji Pythona, które wchodzą w interakcje z bazami danych. Rozumiejąc koncepcje sesji, transakcji, poziomów izolacji i współbieżności oraz postępując zgodnie z najlepszymi praktykami dotyczącymi obsługi wyjątków i puli połączeń, możesz zapewnić integralność danych i zoptymalizować wydajność swoich aplikacji.

Niezależnie od tego, czy budujesz małą aplikację internetową, czy system korporacyjny na dużą skalę, SQLAlchemy zapewnia narzędzia potrzebne do efektywnego zarządzania interakcjami z bazą danych. Pamiętaj, aby zawsze priorytetowo traktować integralność danych i z wdziękiem obsługiwać potencjalne błędy, aby zapewnić niezawodność swoich aplikacji.

Rozważ zapoznanie się z zaawansowanymi tematami, takimi jak:

• Two-Phase Commit (2PC): Dla transakcji obejmujących wiele baz danych.
• Sharding: Do dystrybucji danych na wiele serwerów baz danych.
• Migracje baz danych: Używanie narzędzi takich jak Alembic do zarządzania zmianami schematu bazy danych.